Method for increased concurrency in a computer system

ABSTRACT

A method for enhancing concurrency in a multiprocessor computer system is described. Various tasks in a computer system communicate using commonly accessible mailboxes to access valid data from a location in the mailbox. A task holding the valid data places that data in a mailbox, and other tasks read the valid data from the mailbox. The task that inputs the valid data into the mailbox is caused to notify other tasks addressing the mailbox that the valid data is contained therein. Thus, no central coordination of mailbox access is required. Further, busy waits for valid data are minimized and the ressources of tasks and processors are used more efficiently. By coordinating several lists associated with each mailbox, conflicts in accessing data and delays in obtaining data are also minimized.

This application claims the benefit of Provisional Application No.60/087,891, filed Jun. 3, 1998.

BACKGROUND OF THE INVENTION

The present invention relates generally to multitasking computersystems, and more particularly, to multiprocessor systems and a methodfor increased concurrency in such systems.

Multiprocessor computing systems have been used for years to performmultiple tasks. A multiprocessing computing system may be defined as acomputer assembled from a plurality of independently orsemi-independently operating intelligent, i.e., processor-based,stations. The stations are generally interconnected for communication bya communication bus. Each processor may perform a plurality of taskswith apparent concurrency. Distributing the system intelligence among aplurality of stations may improve the processing throughput of thecomputing system, allow the system to modularly and uniformly expand tomeet increasing computing requirements, and permit greater efficiencyand productivity through concurrency.

While multiprocessor computing systems are known, they are not scalable.The software of such systems is often highly dependent upon theconfiguration and characteristics of the system hardware. This meansthat the scalability of the multiprocessor is limited. Further, thedependency of the software on the hardware often causes a waste inprocessor resources.

Synchronizing or coordinating the tasks using a central processor toenhance concurrency of a plurality of tasks has been problematic in mostmultiprocessor systems. The prior patents of Sullivan, U.S. Pat. Nos.4,484,262, 4,707,781 and 5,438,680, the disclosures of which areincorporated herein by reference, addressed some issues relating toenhancing concurrency.

The Sullivan patents describe that concurrency can be enhanced bycommunicating between processors or tasks via commonly accessible memoryto reduce conflicts within the multiprocessor system. However, thedisclosed techniques are primarily dependent on hardware, such as theprocessors.

Therefore, a need exists for a software-based system that is capable ofenhancing the concurrency of any multiprocessor computing system.

SUMMARY OF THE INVENTION

In one aspect, the invention is directed to a method for operating acomputer system. The computer includes at least one processor. Themethod includes establishing a plurality of memory units each having acorresponding memory location. A plurality of tasks running on theprocessor are executed, and the plurality of tasks are operable to sharedata. A plurality of lists for each memory location are defined, and atleast one of said lists is locked if the data is invalid. An entry isinserted into said locked list corresponding to one of said tasks. Thelocked list is unlocked, and a determination is made if data is inputtedin the memory location between the determining step and the unlockingstep.

In another aspect, the invention is directed to a method for operating acomputer system. The system includes at least one processor. The methodincludes establishing a plurality of memory units each having acorresponding memory location. A plurality of tasks are run on saidprocessor, and the plurality of tasks are operable to share data. Anentry corresponding to one of the tasks is inserted into one of thelists if the list is unlocked. The method also includes determining ifanother of said lists is unlocked if said one list is locked.

In another aspect, the invention is directed to a method forsynchronizing processes in a computer system. The computer systemincludes at least one processor. The method includes establishing aplurality of memory units each having a corresponding memory location. Aplurality of tasks running on the processor are executed, and theplurality of tasks are operable to share data located in the memoryunits. A plurality of lists for each memory location are defined. A listis locked if the data is not valid. An entry is inserted into the lockedlist corresponding to one of the tasks, and the list is unlocked. Theentered task is suspended until valid data is found in the memory unit.The method also includes the steps of reading valid data and determiningif other data appears in said memory location before said locking stepand after said unlocking step. The other data is read if it appears inthe memory unit.

Implementations of the invention include one or more of the following.The locking step further comprises activating selected other ones ofsaid plurality of tasks that are entered on said locked lists. Theplurality of lists may form a linked list. The plurality of lists may bebetween four and eight. The method may also include the step oftransferring the operation of said locked list when said locked list islocked by another one of said plurality of tasks.

In another aspect, the invention is directed to a computer system havingenhanced concurrency that includes a plurality of processors. Aplurality of tasks are run on the plurality of processors. The computersystem may also include a plurality of memory units each having acorresponding memory location, and a plurality of lists corresponding toeach of said memory locations. One of said tasks may be responsible foractivating selected ones of said plurality of tasks contained on thesame list as said one task.

DESCRIPTION OF THE DRAWINGS

FIGS. 1A–1D are flowcharts illustrating a preferred method of readingdata from a mailbox.

FIGS. 2A–2D are flowcharts illustrating a preferred method of inputtingdata in a mailbox.

FIG. 3 is a flowchart of a “one last look” method.

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

The present invention is directed to a system and method for enhancingconcurrency in a multiprocessor or multitasking computer system. Amultitasking computer system may be defined as a computer system thatpermits multiple threads of execution in a single execution space. Amultiprocessing computer system may be defined as a computer system thatallows multiple processing units to share data. Preferably, varioustasks in the computer system communicate using commonly accessible“mailboxes.” A mailbox is an area of memory that contains a number ofstates, and may be identified by a virtual address. When one taskproduces an item of valid data that may be desired by multiple othertasks, the task holding the valid data inputs it into a mailbox.Generally, other tasks read the valid data from the mailbox.

In accordance with a preferred method, the task that inputs the validdata into the mailbox is caused to notify other tasks addressing themailbox that the data is contained therein. This means that there is noneed for central coordination of mailbox accesses. Further, thisminimizes busy waits for valid data. This, permits tasks and processorsto allocate their resources more productively.

As stated above, the mailbox is a memory location. The mailbox includesa pointer to the address corresponding to valid data. Alternatively, anumber, such as a string of zeros, is employed if the data is invalid.For simplicity, the preferred method will be described with reference toinputting or reading data to or from the mailbox. However, the data tobe accessed can be located in the same memory system as the mailbox.Further, the term “task” refers to a set of instructions running on aprocessor. Thus, the processor executes the task. Additionally, theterms “invalid” and “valid” refer to arbitrary logical status. In thepreferred method, a task reads valid data and does not read invaliddata. Other states may be used such as “true” and “false”.

A plurality of lists of tasks wait for valid data associated with themailbox. By coordinating several lists in accordance with the preferredmethod, conflicts in accessing data and delays in obtaining data can beminimized. This is because only a small number of instructions, forexample, under 30, are required to read or place data to or from themailbox. These functions occupy a small percentage of a task's activitytime, such as 5% or less. Accordingly, it has been found that a smallernumber of lists can eliminate most conflicts. However, a list for eachactive task may be required to eliminate all conflicts. Any number oflists may be used. For example, the number of lists may be between fourand eight.

In the preferred method, the lists are a linked list. A linked list canemploy locations in the same memory system as the mailboxes. The linkedlist includes locations having suitable space for at least two pointers.The locations in the middle of the list may contain a forward pointer tothe next location including the list, and a backward pointer to thepreceding location including the list. Additionally, the top location onthe list may contain a pointer forward to the next location and apointer backward to an illegal address, such as zero. The bottomlocation on the list can contain a pointer backward to the precedinglocation and a forward pointer to an illegal address, such as zero. Whenan item, i.e., data, is added to the list, the forward pointercorresponding to the previous bottom location is changed to correspondto the location of the added item. Also, the added item becomes the newbottom location. When the top item is taken from the list, the next itemin the list replaces the top item. Additionally, the backward pointer ofthe added item is changed to point to an illegal address, such as zero.When both pointers of an item in a mailbox are to an invalid address,the list is considered empty.

Reading Valid Data when Available

FIGS. 1A–1D are flow charts showing a preferred method for reading datafrom a mailbox. Initially, data in a mailbox is read (step 101). In thepreferred method, the mailbox may contain a pointer to the memorylocation containing the desired valid data or an illegal addresscorresponding to invalid data, such as zero. The mailbox is thenaddressed and interrogated to determine if the data is valid (step 102).At this stage, a mailbox may contain or is about to contain dataassociated with a program of a task seeking such data. If valid data isin the mailbox, it is read from the memory address indicated in themailbox (step 104). The task may also read the data during step 102.

One aspect described herein is that the task performing steps 101 and102 contacts other tasks waiting for valid data from that mailbox. Thismeans that conflicts are avoided in the multiprocessor system becausebusy waits for valid data are minimized.

FIGS. 1A–1D illustrate lists L0 and L1 that represent tasks waiting toreceive valid data from a mailbox, and FIGS. 2A–2D shows lists L2 and L3that identify tasks waiting to input valid data in the mailbox.

As shown in FIG. 1A, a task list is locked when it is manipulated by atask. This prevents access by other tasks to that list. After list L0 islocked (step 106), the task determines if list L0 was previously lockedby another task (step 108). If list L0 was previously locked by anothertask prior to the current task executing steps 106 or 108, the priortask operates list L0. The current task then proceeds to check list L1(step 122), as described below.

If list L0 was not previously locked (step 108), the current taskdetermines if list L0 is empty (step 110). If the list L0 is not empty,the current task then removes the first waiting task (“waiter”) from thelist (step 116). A waiter may be defined as a task that waits for validdata to be in a mailbox. In this configuration, a waiter may be in asuspended state, as described below. The current task then unlocks listL0 such that other tasks may access the list (step 118). Additionally,the current task causes the task associated with that waiter to executea wake code (step 120). A wake code may be defined as a set of computerinstructions that cause a task to activate from a suspended mode. Then,the current task again locks list L0 (step 106). This process continuesuntil each task on list L0 has been notified, and the list L0 is empty.Alternatively, this process may continue until the list L0 has beenfound locked. If this list is empty, list L0 is unlocked (step 112), andthe task proceeds to check list L1 (step 122), as described below.

If list L0 was previously locked (step 108), the current task locks listL1 (step 122), and then checks if that list was previously locked (step124). If list L1 was not previously locked at step 126, the current taskdetermines if list L1 is empty (step 128). If list L1 is not empty, thecurrent task removes the waiters from list L1 (step 132) and causes thewaiters to execute their wake codes (step 134), as described above. Thisprocess repeats until list L1 is empty or the list L1 has been foundlocked. When list L1 is empty, it is unlocked (step 130). The task thencontinues to execute its remaining instructions as defined by the system(step 126). If list L1 was previously locked by another task prior tosteps 122, 124 or 126, that task operates the locked list. The currenttask then executes step 126.

Valid Data not Available

If no valid data is found at the mailbox (step 102), list L0 is locked(step 140). The current task then determines if list L0 was previouslylocked (step 142). If the list was not previously locked, the currenttask is entered on list L0 (step 144). List L0 is then unlocked (step146), and the current task checks for valid data (step 148). The currenttasks then determines the validity of the data (step 150). This aboveprocess may be referred to as “one last look.” as described below. Inthe preferred method, this configuration keeps two or more tasks, whichare synchronized by passing data through the mailbox, from missing eachother.

If the data is still not valid at step 150, the task is suspended (step152). This releases computer system resources for other tasks, or thetask can complete other system instructions. This means that the taskdoes not busy wait or periodically check for valid data in the memorylocation. The current task will be activated by another task which hasfound valid data in the memory location, or by a task which previouslyinputted the valid data (step 154). When activated by another task, thecurrent task proceeds to read the valid data from the mailbox (step104). If the data is valid (step 150) and list L0 was previously locked(steps 156 and 158), the current task is suspended until activated(steps 152 and 154). When activated by another task, the current taskproceeds to read the valid data from the mailbox (step 104).

If the data was valid (step 150) and the current task determines thatlist L0 was not locked (step 156 and 158), the current task reads thedata. This may occur as the current task determines the validity of thedata. Then, the current task executes step 202.

If the current task is on the list L0 at step 202, the current task isremoved from the list (step 204). The next waiting task is also removedfrom the list L0 (step 206), and list L0 is again unlocked (step 208).The task then causes the other task removed from the list to execute itswake code (step 210).

Next, in accordance with the preferred method, the current taskdetermines if the list L0 was previously locked (steps 212 and 214). Ifso, the current task then executes other system instructions (step 220).If the list was not previously locked, the current task then determinesif the list is empty (step 216).

If list L0 is not empty (step 216), the current task loops back toremove and notify the next task at the top of the list (steps 206–216).If on any such loop, the list is found locked at steps 214 or 216, thecurrent task continues to perform other system instructions (steps 220).When the list is empty, it is unlocked (step 218) and the current taskcontinues to perform other system instructions (step 220).

The current task may not be on the list L0 (step 202). This means thatanother task has removed the current task from the list and is operatingto activate it. However, the current task also operates list L0. Thus,the current task must activate the other tasks on list L0. The currenttask may then suspend itself until activated by another task.

Steps 228 through 238 operate similar to steps 206 through 218. However,when list L0 is found locked (step 234) or empty (step 236), the currenttask is suspended (step 240). When activated by another task (step 242),the current task proceeds to read the valid data from the mailbox (step104).

Referring again to FIG. 1B, if list L0 was locked (step 142), thecurrent task proceeds as follows. List L1 is locked and then the currenttask determines whether that list was previously locked (steps 180 and182). If list L1 was previously locked, the current task returns to locklist L0 (step 140), and continues to search for an unlocked list. Thisexample provides two possible lists. However, more lists may be used. Ifthe number of lists equals the number of tasks, no task will repeat thisloop.

If list L1 was not previously locked (step 182), the current taskbecomes a waiter on list L1 (step 184), the list L1 is unlocked (step186), and a “one last look” check is made for valid data (steps 188 and190). If the data is not valid, the current task is suspended (step152).

If the data is valid (step 190), then the current task reads the data asit confirms the validity of the data. List L1 is then locked (step 192),and a check is made whether it was previously locked (step 194). If listL1 was previously locked (step 194), list L1 is unlocked (step 196), andthe current task is suspended (step 152).

If the data was valid and it is determined that list L1 was not locked,at steps 190, 194, and 196, respectively, then the current task proceeds(step 252).

FIG. 1D shows that if the current task is on list L1 (step 252) thattask is removed from the list (step 254), and also removes the nextwaiting task from the list L1 (step 256). The task then unlocks list L1again (step 258). The task then causes the other task removed from thelist to execute its wake code (step 260).

Next, the current task determines whether the list L1 was previouslylocked (steps 262 and 264). If it was not previously locked, the currenttask determines whether the list is empty (step 266).

If list L1 is not empty (step 266), the current task loops back toactivates task at the top of the list (steps 256 through 266). If on anysuch loop, the list is found locked at steps 264 or 266, the currenttask continues step (270). When the list is empty, it is unlocked (step261), and the current task continues to execute other systeminstructions (step 270).

If the current task is not found on the list L1 (step 252), this meansthat some other task has taken the current task off the list and isattempting to activate it. The current task also operates list L1. Thus,this task must activate the other tasks on list L1 before suspendingitself. The current task can then be activated by another task. Themethod of steps 278 through 288 is similar to steps 256 through 268described above. However, when list L1 is found locked (step 284) orempty (step 286), the current task is suspended (step 290). Whenactivated by another task (step 292), the current task proceeds to readthe valid data from the mailbox at step 104.

This preferred method of finding an available list is simple. Further, atask should not be significantly delayed in finding an unlocked list.Thus, enhanced concurrency can be achieved over prior systems.

Inputting Valid Data

FIGS. 2A–2D are flow charts showing the input of data into a mailbox inaccordance with the preferred method. Initially, data is read in amailbox (step 301). The mailbox is then addressed and interrogated todetermine whether the data is valid (step 302). If valid data is notalready in that mailbox, the mailbox is marked as not containing validdata. Next, the valid data is placed in the mailbox (step 304).

In accordance with the preferred method, lists L2 and L3 identify taskswaiting to input valid data in the mailbox. This includes a current taskwaiting to input data in the mailbox. The current task determineswhether list L2 was previously locked (step 304). If so, that listremains locked (step 306). If list L2 was not previously locked, thecurrent task determines whether list L2 is empty (step 310). If the listL2 is not empty, then the current task removes the first waiter fromthat list (step 316). Also, the current task unlocks list L2 so thatother tasks may access it (step 318), and causes the task associatedwith that waiter to execute its wake code (step 320). Then, the currenttask locks list L2 again (step 306). The above process continues fromstep 306 until all tasks on list L2 seeking the valid data from themailbox have been activated. Alternatively, this process continues untilthe list L2 is empty, or the list L2 has been found locked. When list L2is found empty, it is unlocked (step 312), and the current task proceedsto list L3 (step 322).

If list L2 was previously locked (step 301) or list L2 was found empty(step 310) and then unlocked (step 312), the current task then lockslist L3 (step 322). Then, the current task checks if list L3 waspreviously locked (step 324). If list L3 was not previously locked, thecurrent task determines whether list L3 is empty (step 328). If list L3is not empty, the current task proceeds to remove the waiters from listL3 (steps 332 and 334) and causes them to execute their wake codes (step306). This process repeats by looping back to step 322. The process maycontinue until list L3 is empty or has been found locked. When list L3is empty, it is unlocked and the current task continues to execute othersystem instructions (steps 330 and 338). If list L3 is found to havebeen previously locked at steps 322 or 324, this indicates activity byanother task. The current task then executes other system activities(step 338). The current task also defers to the other task to activatethe other tasks listed on list L3.

Valid Data Found in Mailbox

If the current task determines that there is valid data at the memorylocation (step 302), the list L2 is locked (step 340). The current taskalso checks whether the list was previously locked (step 342). If listL2 was not previously locked, the current task is inserted onto list L2(step 344). List L2 is then unlocked (step 346) and a “one last look”check is made for valid data (steps 348 and 350), as described below. Ifthe data is still invalid, the current task is suspended (step 352). Thecurrent task is then activated by another task that has found orinputted valid data in the memory location (step 354).

If the data in the mailbox is valid and list L2 was previously locked(steps 356 and 358), the current task is suspended until activated(steps 352 and 354). When activated by another task, the current taskproceeds to input valid data into the mailbox (step 304).

If the data was not valid (step 350) and list L2 was not previouslylocked (steps 356 and 358), the current task continues to execute othersystem commands (step 402).

If the current task is on list L2 (step 402) the current task removesitself from that list (step 404). Also, the current task removes thenext waiting task from the list L2 (step 406) and unlocks list L2 again(step 408). The current task then causes the other task to be removedfrom the list to execute its wake code (step 410).

In accordance with the preferred method, the current task determineswhether the list L2 was previously locked (steps 412 and 414). If so,the current task proceeds to input valid data in the mailbox (step 304).Otherwise, the current task determines whether the list is empty (step416).

If list L2 is not empty (step 416), the current task loops back toremove and activate the next task at the top of the list (steps406–416). If on any such loop, the list is locked at steps 414 or 416,the current task inputs valid data in the mailbox (step 304). When thelist is empty, it is unlocked (step 418). The current task then inputsvalid data in the mailbox (step 304).

If the task is not on the list L2 (step 402), the current task may beremoved from the list and is being activated by another task. Thecurrent task also operates list L2. Thus, the current task must activatethe other tasks which are on list L2 before suspending itself. Thecurrent task may then be activated by another task. The method of steps428 through 438 is similar to steps 406–418. However, when list L2 isfound previously locked (step 434) or empty (step 436), the current taskis suspended (step 440). When activated by another task (step 442), thecurrent task proceeds to input valid data in the mailbox (step 304).

If list L2 was previously locked at step 342, the current task lockslist L3 (step 380) and then determines whether that list was previouslylocked (step 382). If list L3 was previously locked, the current taskloops back to attempt to access list L2 (step 340), and continues tofind an unlocked list. This example provides two possible lists.However, more than two lists may be employed.

If list L3 was not previously locked (step 382), the current task isinserted on list L3 as a waiter (step 384). The list L3 is also unlocked(step 386), and a “one last look” check is made for valid data (steps388 and 390), as described below. If the data is valid, the current taskis suspended (step 352).

If the data is not valid (step 390), list L3 is locked, (step 392) and acheck is made whether list L3 was previously locked (step 394). If listL3 was previously locked, list L3 is unlocked (step 396), and thecurrent task is suspended (step 352).

If the data was not valid and the list L3 was not previously locked(steps 390, 394, and 396), the current task proceeds to step 452.

If the current task is on list L3 (step 452), it is removed from thatlist (step 454). Also, the next waiting task from the list L3 is removed(step 456), and the current task unlocks list L3 again (step 458). Thecurrent task then causes the other task removed from the list to executeits wake code (step 460).

The current task then determines whether the list L3 was previouslylocked (steps 462 and 464). If it was not previously locked, the currenttask determines whether the list is empty (step 466).

If list L3 is not empty, the current task loops back to remove andactivate the next task at the top of the list (steps 456–466). If on anysuch loop, the list is locked (steps 464 and 466), the current taskinputs valid data in the mailbox (steps 304). When the list is empty, itis unlocked (step 468), and the current task determines if valid data isinputted in the mailbox (step 304).

If the current task does not find itself on list L3 (step 452), this maybe because some other task has taken the task off the list and is tryingto activate it. The current task, however, operates list L3. Thus, thecurrent task must activate other tasks on list L3 before suspendingitself. The current task then may be activated by another task. Themethod of steps 478 through 488 is similar to steps 456 through 468.However, when list L3 is found previously locked (step 484) or empty(step 486), the current task is suspended (step 490). When activated byanother task (step 492), the current task proceeds to input valid datain the mailbox (step 304).

One Last Look

The term “one last look” refers to the situation where a task that hasplaced itself on a list for valid data from a mailbox receives thatdata. The preferred method allows tasks addressing the same mailbox tobe coordinated. This means that a current task inputting valid data in amailbox will activate another task that was entered onto a wait list,while the data was placed in the mailbox by the current task.Accordingly, a current task may not input valid data in the mailbox,while another task is inserted on a list to receive that data. Thepreferred method avoids the potentially infinite period of time that atask may sleep until another task activates it. Thus, delays in systemprocessing time may be minimized.

FIG. 3 shows that a task first looks at the data in the selected mailboxand determines whether it is valid data (steps 548 and 550). If the datais valid, it reads the data and continues with other system activities(steps 551 and 553).

At this stage, if the data is not valid, the task is inserted onto await list (step 555). Then, the “one last look” determines if the datais valid (steps 557 and 559). This occurs because, while the task thatmay have located an unlocked list, locked it, placed itself on the listand unlocked the list again, another task may have put valid data in themailbox. Without this preferred “one last look” method, activating theinserted task may be delayed until another task seeks valid data fromthe mailbox.

If the data is not valid at that time, the task will suspend untilactivated by another task, such as the next task inputting valid data inthe mailbox (steps 552 and 554). This method corresponds generally tosteps 352 and 354.

If the data is valid at that time (step 559), the task can take itselfoff the list (step 561). Alternatively, the task may read the data andcontinue its other system activities. This means that the task mayassume that the data was initially found in the mailbox (steps 563 and553). A number of embodiments of the present invention have beendescribed. Nevertheless, it will be understood that variousmodifications may be made without departing from the spirit and scope ofthe invention. For example, the number of lists may be increased toaccommodate additional tasks. Accordingly, it is to be understood thatthe invention is not to be limited by the specific illustratedembodiments, but only by the scope of the appended claims.

1. A method for operating a computer system, said computer systemincluding at least one processor, comprising: establishing a pluralityof memory units each having a corresponding memory location; executing aplurality of tasks running on said at least one processor, saidplurality of tasks being operable to share data; defining a plurality oflists for each memory location; determining the validity of said data inone memory unit of said plurality of memory units; locking at least oneof said plurality of lists if said data is invalid; inserting an entrycorresponding to one of said plurality of tasks onto said locked list;unlocking said locked list; and determining if data is inputted in saidcorresponding memory location of said one memory unit between saiddetermining step and said unlocking step.
 2. A method for operating acomputer system, said computer system comprising at least one processor,comprising: establishing a plurality of memory units each having acorresponding memory location; running a plurality of tasks on saidprocessor, said plurality of tasks being operable to share data;defining a plurality of lists for each memory location; inserting anentry corresponding to one of said plurality of tasks onto one of saidplurality of lists if said one list is unlocked; and determining ifanother of said lists is unlocked if said one list is locked.
 3. Amethod for synchronizing processes in a computer system, said computersystem including at least one processor, comprising: establishing aplurality of memory units each having a corresponding memory location;executing a plurality of tasks running on said processor, said pluralityof tasks being operable to share data located in said memory units;defining a plurality of lists for each memory location; locking at leastone of said plurality of lists if said data is not valid in one of saidplurality of memory units; inserting an entry corresponding to one ofsaid plurality of tasks onto said locked list; unlocking said lockedlist; suspending said one of said plurality of tasks until valid data isfound in said member of said memory units; reading said valid data;determining if other data is inputted in said one of said memory unitsafter said locking step and before said unlocking step; and reading saidother data if said other data appears in said memory unit.
 4. The methodof claim 3, wherein the locking step further comprises activatingselected other ones of said plurality of tasks that are entered on saidlocked list.
 5. The method of claim 3, wherein said plurality of listsincludes a linked list.
 6. The method of claim 3, wherein said pluralityof lists is between four and eight.
 7. The method of claim 3, furthercomprising transferring the operation of said locked list when saidlocked list is locked by another one of said plurality of tasks.
 8. Acomputer system having enhanced concurrency, comprising: a plurality ofprocessors; a plurality of tasks running on said plurality ofprocessors; a plurality of memory units each having a correspondingmemory location; a plurality of lists corresponding to each of saidmemory location; wherein one of said plurality of tasks is responsiblefor activating selected ones of said plurality of tasks contained on thesame list as said one task.
 9. The system of claim 8, wherein saidplurality of lists form a linked list.
 10. The system of claim 8,wherein said plurality of lists is between four and eight.
 11. Thesystem of claim 8, wherein said computer system is a multitasking ormultiprocessing computer system.
 12. A method of operating a computersystem having at least one processor, comprising: determining thevalidity of data in a memory unit; locking a list corresponding to saidmemory unit if said data is invalid; inserting an entry corresponding toone of a plurality of tasks onto said locked list; unlocking said lockedlist; and determining if data is inputted in a memory location withinsaid memory unit between said determining step and said unlocking step.